home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp95 / freyja_t.z / freyja_t / xprintf.c < prev    next >
C/C++ Source or Header  |  1992-04-14  |  15KB  |  868 lines
  1. /* XPRINTF.C -- Printf with Extensions/Deletions
  2.  
  3.     Written February 1988 by Craig Finseth
  4.  
  5. THE NON-VARARGS VERSION ASSUMES THAT sizeof(pointer) >= sizeof(int)
  6. */
  7.  
  8. #include "fgenlib.h"
  9.  
  10. #if defined(VARARGS)
  11. enum XP_STATE { XP_ARG, XP_CASE, XP_COMMA, XP_C, XP_D, XP_H, XP_L,
  12.     XP_O, XP_R, XP_S, XP_U, XP_X, XP_DONE };
  13. enum XP_TYPE { XP_CPT, XP_IT, XP_LT, XP_RT, XP_DONET };
  14. #endif
  15.  
  16. void x_printput();        /* const char c */
  17. void x_printrput();        /* const char c */
  18.  
  19. static void (*put)() = x_printput;
  20. static void (*rput)() = x_printrput;
  21.  
  22. static char printbuf[BUFFSIZE / 2];
  23. static char *printptr;
  24. static char *strptr;
  25.  
  26. static int outfd = 1;        /* output file descriptor */
  27.  
  28. #if defined(VARARGS)
  29. static FLAG iszero;
  30. static FLAG isarg;
  31. static unsigned arg;
  32. static char *format;
  33. static enum XP_STATE state;
  34.  
  35. enum XP_TYPE x_chunk();        /* void */
  36. void x_chunkcp();        /* char *val */
  37. void x_chunki();        /* int val */
  38. void x_chunkl();        /* long val */
  39. void x_chunkr();        /* char *val1, int *val2 */
  40. #endif
  41.  
  42. void x_printf2();        /* const char *fmt, int *parms */
  43. void x_printnum();        /* unsigned value, const int base,
  44.                 const int len, const FLAG notfirst,
  45.                 const FLAG iszero */
  46. void x_printlong();        /* long value, const int base,
  47.                 const int len, const FLAG notfirst,
  48.                 const FLAG iszero */
  49. void x_printcomma();        /* unsigned value, const int len,
  50.                 const int depth */
  51. void x_printsput();        /* const char c */
  52.  
  53. /* ------------------------------------------------------------ */
  54.  
  55. void
  56. #if defined(VARARGS)
  57. #if defined(__STDC__)
  58. xprintf(char *fmt, ...)
  59. #else
  60. xprintf(va_alist)
  61.     va_dcl
  62. #endif
  63.     {
  64.     va_list ap;
  65.     char *cp;
  66.     int *ip;
  67.     long l;
  68.     int i;
  69.  
  70. #if defined(__STDC__)
  71.     va_start(ap, fmt);
  72.     format = fmt;
  73. #else
  74.     va_start(ap);
  75.     format = va_arg(ap, char *);
  76. #endif
  77.     printptr = printbuf;
  78.     state = XP_DONE;
  79.     do    {
  80.         switch (x_chunk()) {
  81.  
  82.         case XP_CPT:
  83.             cp = va_arg(ap, char *);
  84.             x_chunkcp(cp);
  85.             break;
  86.  
  87.         case XP_IT:
  88.             i = va_arg(ap, int);
  89.             x_chunki(i);
  90.             break;
  91.  
  92.         case XP_LT:
  93.             l = va_arg(ap, long);
  94.             x_chunkl(l);
  95.             break;
  96.  
  97.         case XP_RT:
  98.             cp = va_arg(ap, char *);
  99.             ip = va_arg(ap, int *);
  100.             x_chunkr(cp, ip);
  101.             break;
  102.             }
  103.         } while (state != XP_DONE);
  104.     va_end(ap);
  105. #else
  106. xprintf(format, args)
  107.     char *format;
  108.     int args;
  109.     {
  110.     printptr = printbuf;
  111.     x_printf2(format, &args);
  112. #endif
  113.     write(1, printbuf, printptr - printbuf);
  114.     }
  115.  
  116.  
  117. /* ------------------------------------------------------------ */
  118.  
  119. void
  120. #if defined(VARARGS)
  121. #if defined(__STDC__)
  122. xdprintf(int fd, char *fmt, ...)
  123.     {
  124. #else
  125. xdprintf(va_alist)
  126.     va_dcl
  127.     {
  128.     int fd;
  129. #endif
  130.     va_list ap;
  131.     char *cp;
  132.     int *ip;
  133.     long l;
  134.     int i;
  135.  
  136. #if defined(__STDC__)
  137.     va_start(ap, fmt);
  138.     format = fmt;
  139. #else
  140.     va_start(ap);
  141.     fd = va_arg(ap, int);
  142.     format = va_arg(ap, char *);
  143. #endif
  144.     outfd = fd;
  145.     printptr = printbuf;
  146.     state = XP_DONE;
  147.     do    {
  148.         switch (x_chunk()) {
  149.  
  150.         case XP_CPT:
  151.             cp = va_arg(ap, char *);
  152.             x_chunkcp(cp);
  153.             break;
  154.  
  155.         case XP_IT:
  156.             i = va_arg(ap, int);
  157.             x_chunki(i);
  158.             break;
  159.  
  160.         case XP_LT:
  161.             l = va_arg(ap, long);
  162.             x_chunkl(l);
  163.             break;
  164.  
  165.         case XP_RT:
  166.             cp = va_arg(ap, char *);
  167.             ip = va_arg(ap, int *);
  168.             x_chunkr(cp, ip);
  169.             break;
  170.             }
  171.         } while (state != XP_DONE);
  172.     va_end(ap);
  173. #else
  174. xdprintf(fd, format, args)
  175.     int fd;
  176.     char *format;
  177.     int args;
  178.     {
  179.     outfd = fd;
  180.     printptr = printbuf;
  181.     x_printf2(format, &args);
  182. #endif
  183.     write(fd, printbuf, printptr - printbuf);
  184.     outfd = 1;
  185.     }
  186.  
  187.  
  188. /* ------------------------------------------------------------ */
  189.  
  190. void
  191. #if defined(VARARGS)
  192. #if defined(__STDC__)
  193. xeprintf(char *fmt, ...)
  194. #else
  195. xeprintf(va_alist)
  196.     va_dcl
  197. #endif
  198.     {
  199.     va_list ap;
  200.     char *cp;
  201.     int *ip;
  202.     long l;
  203.     int i;
  204.  
  205. #if defined(__STDC__)
  206.     va_start(ap, fmt);
  207.     format = fmt;
  208. #else
  209.     va_start(ap);
  210.     format = va_arg(ap, char *);
  211. #endif
  212.     outfd = 2;
  213.     printptr = printbuf;
  214.     state = XP_DONE;
  215.     do    {
  216.         switch (x_chunk()) {
  217.  
  218.         case XP_CPT:
  219.             cp = va_arg(ap, char *);
  220.             x_chunkcp(cp);
  221.             break;
  222.  
  223.         case XP_IT:
  224.             i = va_arg(ap, int);
  225.             x_chunki(i);
  226.             break;
  227.  
  228.         case XP_LT:
  229.             l = va_arg(ap, long);
  230.             x_chunkl(l);
  231.             break;
  232.  
  233.         case XP_RT:
  234.             cp = va_arg(ap, char *);
  235.             ip = va_arg(ap, int *);
  236.             x_chunkr(cp, ip);
  237.             break;
  238.             }
  239.         } while (state != XP_DONE);
  240.     va_end(ap);
  241. #else
  242. xeprintf(format, args)
  243.     char *format;
  244.     int args;
  245.     {
  246.     outfd = 2;
  247.     printptr = printbuf;
  248.     x_printf2(format, &args);
  249. #endif
  250.     write(2, printbuf, printptr - printbuf);
  251.     outfd = 1;
  252.     }
  253.  
  254.  
  255. /* ------------------------------------------------------------ */
  256.  
  257. void
  258. #if defined(VARARGS)
  259. #if defined(__STDC__)
  260. xsprintf(char *string, char *fmt, ...)
  261.     {
  262. #else
  263. xsprintf(va_alist)
  264.     va_dcl
  265.     {
  266.     char *string;
  267. #endif
  268.     va_list ap;
  269.     char *cp;
  270.     int *ip;
  271.     long l;
  272.     int i;
  273.  
  274. #if defined(__STDC__)
  275.     va_start(ap, fmt);
  276.     format = fmt;
  277. #else
  278.     va_start(ap);
  279.     string = va_arg(ap, char *);
  280.     format = va_arg(ap, char *);
  281. #endif
  282.     put = x_printsput;
  283.     rput = x_printsput;
  284.     strptr = string;
  285.     state = XP_DONE;
  286.     do    {
  287.         switch (x_chunk()) {
  288.  
  289.         case XP_CPT:
  290.             cp = va_arg(ap, char *);
  291.             x_chunkcp(cp);
  292.             break;
  293.  
  294.         case XP_IT:
  295.             i = va_arg(ap, int);
  296.             x_chunki(i);
  297.             break;
  298.  
  299.         case XP_LT:
  300.             l = va_arg(ap, long);
  301.             x_chunkl(l);
  302.             break;
  303.  
  304.         case XP_RT:
  305.             cp = va_arg(ap, char *);
  306.             ip = va_arg(ap, int *);
  307.             x_chunkr(cp, ip);
  308.             break;
  309.             }
  310.         } while (state != XP_DONE);
  311.     va_end(ap);
  312. #else
  313. xsprintf(string, format, args)
  314.     char *string;
  315.     char *format;
  316.     int args;
  317.     {
  318.     put = x_printsput;
  319.     rput = x_printsput;
  320.     strptr = string;
  321.     x_printf2(format, &args);
  322. #endif
  323.     *strptr = NUL;
  324.     put = x_printput;
  325.     rput = x_printrput;
  326.     }
  327.  
  328.  
  329. /* ------------------------------------------------------------ */
  330.  
  331. /* Process the format string up to the next % argument, updating the
  332. static FORMAT.  Return the expected type.  Update STATE with the new
  333. state and ARG, ISARG, and ISZERO with the argument information. */
  334.  
  335. #if defined(VARARGS)
  336. enum XP_TYPE
  337. x_chunk()
  338.     {
  339.  
  340.     while (*format != NUL) {
  341.         if (state != XP_ARG && state != XP_CASE) {
  342.             if (*format != '%') {
  343.                 (*put)(*format++);
  344.                 continue;
  345.                 }
  346.  
  347.             arg = 0;
  348.             isarg = FALSE;
  349.             if (*++format == '*') {
  350.                 format++;
  351.                 state = XP_ARG;
  352.                 return(XP_IT);
  353.                 }
  354.             else if (xisdigit(*format)) {
  355.                 iszero = *format == '0';
  356.                 while (xisdigit(*format)) {
  357.                     arg = arg * 10 + *format++ - '0';
  358.                     }
  359.                 isarg = TRUE;
  360.                 }
  361.             else arg = 1;
  362.             }
  363.  
  364.         if (state == XP_CASE) {
  365.             while (arg-- > 0) {
  366.                 while (*format != NUL && (*format++ != '%' ||
  367.                      (*format != ';' && *format != ':' &&
  368.                       *format != ']'))) {
  369.                     if (*(format - 1) == '%' &&
  370.                          *format == '%') format++;
  371.                     }
  372.                 if (*format != ';') arg = 0;
  373.                 }
  374.             if (*format == ';' || *format == ':' || *format == ']')
  375.                 format++;
  376.             if (*format == NUL) format--;
  377.             state = XP_DONE;
  378.             continue;
  379.             }
  380.         state = XP_DONE;
  381.  
  382.         switch (xtoupper(*format++)) {
  383.  
  384.         case '%':
  385.             while (arg-- > 0) (*rput)('%');
  386.             break;
  387.  
  388.         case '[':        /* CASE statment */
  389.             state = XP_CASE;
  390.             return(XP_IT);
  391.             /*break;*/
  392.  
  393.         case ']':
  394.             break;
  395.  
  396.         case ';':
  397.         case ':':
  398.             while (*format != NUL &&
  399.                  (*format++ != '%' || *format != ']')) {
  400.                 if (*(format - 1) == '%' && *format == '%')
  401.                     format++;
  402.                 }
  403.             if (*format == ']') format++;
  404.             if (*format == NUL) format--;
  405.             break;
  406.  
  407.         case 'R':        /* recursion */
  408.             state = XP_R;
  409.             return(XP_RT);
  410.             /*break;*/
  411.  
  412.         case ',':        /* numbers */
  413.             state = XP_COMMA;
  414.             return(XP_IT);
  415.             /*break;*/
  416.  
  417.         case 'D':
  418.             state = XP_D;
  419.             return(XP_IT);
  420.             /*break;*/
  421.  
  422.         case 'H':        /* long hexadecimal */
  423.             state = XP_H;
  424.             return(XP_LT);
  425.             /*break;*/
  426.  
  427.         case 'L':
  428.             state = XP_L;
  429.             return(XP_LT);
  430.             /*break;*/
  431.  
  432.         case 'O':
  433.             state = XP_O;
  434.             return(XP_IT);
  435.             /*break;*/
  436.  
  437.         case 'X':
  438.             state = XP_X;
  439.             return(XP_IT);
  440.             /*break;*/
  441.  
  442.         case 'U':
  443.             state = XP_U;
  444.             return(XP_IT);
  445.             /*break;*/
  446.  
  447.         case 'S':        /* strings */
  448.             state = XP_S;
  449.             return(XP_CPT);
  450.             /*break;*/
  451.  
  452.         case 'C':        /* characters */
  453.             state = XP_C;
  454.             return(XP_IT);
  455.             /*break;*/
  456.  
  457.         case 'Z':        /* NUL's */
  458.             while (arg-- > 0) (*rput)(NUL);
  459.             break;
  460.  
  461.         case DEL:
  462.             while (arg-- > 0) (*rput)(DEL);
  463.             break;
  464.  
  465.         case SP:
  466.             while (arg-- > 0) (*rput)(SP);
  467.             break;
  468.  
  469.         default:
  470.             break;
  471.             }
  472.         }
  473.     state = XP_DONE;
  474.     return(XP_DONET);
  475.     }
  476. #endif
  477.  
  478.  
  479. /* ------------------------------------------------------------ */
  480.  
  481. /* Print value VAL.  Import STATE, ARG, and ISARG as a static. */
  482.  
  483. #if defined(VARARGS)
  484. void
  485. x_chunkcp(val)
  486.     char *val;
  487.     {
  488.     int tmp;
  489.  
  490.     switch (state) {
  491.  
  492.     case XP_S:
  493.         if (isarg) tmp = strlen(val);
  494.         while (*val != NUL) (*put)(*val++);
  495.         if (isarg) while (tmp++ < arg) (*put)(SP);
  496.         break;
  497.         }
  498.     }
  499. #endif
  500.  
  501.  
  502. /* ------------------------------------------------------------ */
  503.  
  504. /* Print value VAL.  Import STATE, ARG, and ISZERO as a static. */
  505.  
  506. #if defined(VARARGS)
  507. void
  508. x_chunki(val)
  509.     long val;
  510.     {
  511.     switch (state) {
  512.  
  513.     case XP_ARG:
  514.     case XP_CASE:
  515.         arg = val;
  516.         isarg = TRUE;
  517.         iszero = FALSE;
  518.         break;
  519.  
  520.     case XP_COMMA:
  521.         if (val < 0) {
  522.             (*put)('-');
  523.             val = -val;
  524.             }
  525.         x_printcomma(val, arg, 0);
  526.         break;
  527.  
  528.     case XP_C:
  529.         (*put)(val);
  530.         break;
  531.  
  532.     case XP_D:
  533.         if (val < 0) {
  534.             (*put)('-');
  535.             val = -val;
  536.             }
  537.         x_printnum(val, 10, arg, FALSE, iszero);
  538.         break;
  539.  
  540.     case XP_O:
  541.         x_printnum(val, 8, arg, FALSE, iszero);
  542.         break;
  543.  
  544.     case XP_U:
  545.         x_printnum(val, 10, arg, FALSE, iszero);
  546.         break;
  547.  
  548.     case XP_X:
  549.         x_printnum(val, 16, arg, FALSE, iszero);
  550.         break;
  551.         }
  552.     }
  553. #endif
  554.  
  555.  
  556. /* ------------------------------------------------------------ */
  557.  
  558. /* Print value VAL.  Import STATE, ARG, and ISZERO as a static. */
  559.  
  560. #if defined(VARARGS)
  561. void
  562. x_chunkl(val)
  563.     long val;
  564.     {
  565.     switch (state) {
  566.  
  567.     case XP_H:
  568.         x_printlong(val, 16, arg, FALSE, iszero);
  569.         break;
  570.  
  571.     case XP_L:
  572.         if (val < 0) {
  573.             (*put)('-');
  574.             val = -val;
  575.             }
  576.         x_printlong(val, 10, arg, FALSE, iszero);
  577.         break;
  578.         }
  579.     }
  580. #endif
  581.  
  582.  
  583. /* ------------------------------------------------------------ */
  584.  
  585. /* Print values VAL1 and VAL2.  Import STATE as a static. */
  586.  
  587. #if defined(VARARGS)
  588. void
  589. x_chunkr(val1, val2)
  590.     char *val1;
  591.     int *val2;
  592.     {
  593.     switch (state) {
  594.  
  595.     case XP_R:
  596.         x_printf2(val1, val2);
  597.         break;
  598.         }
  599.     }
  600. #endif
  601.  
  602.  
  603. /* ------------------------------------------------------------ */
  604.  
  605. void
  606. x_printf2(fmt, parms)
  607.     char *fmt;
  608.     int *parms;
  609.     {
  610.     FLAG iszero;
  611.     FLAG isarg;
  612.     unsigned arg;
  613.     char *cptr;
  614.     char **cptrptr;
  615.     int tmp;
  616.     long *lptr;
  617.     long ltmp;
  618.  
  619.     while (*fmt != NUL) {
  620.         if (*fmt != '%') {
  621.             (*put)(*fmt++);
  622.             continue;
  623.             }
  624.  
  625.         arg = 0;
  626.         isarg = FALSE;
  627.         if (*++fmt == '*') {
  628.             arg = *parms++;
  629.             fmt++;
  630.             isarg = TRUE;
  631.             }
  632.         else if (xisdigit(*fmt)) {
  633.             iszero = *fmt == '0';
  634.             while (xisdigit(*fmt)) {
  635.                 arg = arg * 10 + *fmt++ - '0';
  636.                 }
  637.             isarg = TRUE;
  638.             }
  639.         else    arg = 1;
  640.  
  641.         switch (xtoupper(*fmt++)) {
  642.  
  643.         case '%':
  644.             while (arg-- > 0) (*rput)('%');
  645.             break;
  646.  
  647.         case '[':        /* CASE statment */
  648.             arg = *parms++;
  649.             while (arg-- > 0) {
  650.                 while (*fmt != NUL && (*fmt++ != '%' ||
  651.                      (*fmt != ';' && *fmt != ':' &&
  652.                       *fmt != ']'))) {
  653.                     if (*(fmt - 1) == '%' &&
  654.                         *fmt == '%') fmt++;
  655.                     }
  656.                 if (*fmt != ';') arg = 0;
  657.                 }
  658.             if (*fmt == NUL) fmt--;
  659.             break;
  660.  
  661.         case ']':
  662.             break;
  663.  
  664.         case ';':
  665.         case ':':
  666.             while (*fmt != NUL &&
  667.                  (*fmt++ != '%' || *fmt != ']')) {
  668.                 if (*(fmt - 1) == '%' && *fmt == '%')
  669.                     fmt++;
  670.                 }
  671.             if (*fmt == NUL) fmt--;
  672.             break;
  673.  
  674.         case 'R':        /* recursion */
  675.             cptrptr = (char **)parms;
  676.             cptr = *cptrptr++;
  677.             parms = (int *)cptrptr;
  678.             x_printf2(cptr, (int *)*parms++);
  679.             break;
  680.  
  681.         case ',':        /* numbers */
  682.             tmp = *parms++;
  683.             if (tmp < 0) {
  684.                 (*put)('-');
  685.                 tmp = -tmp;
  686.                 }
  687.             x_printcomma(tmp, arg, 0);
  688.             break;
  689.  
  690.         case 'D':
  691.             tmp = *parms++;
  692.             if (tmp < 0) {
  693.                 (*put)('-');
  694.                 tmp = -tmp;
  695.                 }
  696.             x_printnum(tmp, 10, arg, FALSE, iszero);
  697.             break;
  698.  
  699.         case 'H':        /* long hexadecimal */
  700.             lptr = (long *)parms;
  701.             x_printlong(*lptr++, 16, arg, FALSE, iszero);
  702.             parms = (int *)lptr;
  703.             break;
  704.  
  705.         case 'L':
  706.             lptr = (long *)parms;
  707.             ltmp = *lptr++;
  708.             if (ltmp < 0) {
  709.                 (*put)('-');
  710.                 ltmp = -ltmp;
  711.                 }
  712.             x_printlong(ltmp, 10, arg, FALSE, iszero);
  713.             parms = (int *)lptr;
  714.             break;
  715.  
  716.         case 'O':
  717.             x_printnum(*parms++, 8, arg, FALSE, iszero);
  718.             break;
  719.  
  720.         case 'X':
  721.             x_printnum(*parms++, 16, arg, FALSE, iszero);
  722.             break;
  723.  
  724.         case 'U':
  725.             x_printnum(*parms++, 10, arg, FALSE, iszero);
  726.             break;
  727.  
  728.         case 'S':        /* strings */
  729.             cptrptr = (char **)parms;
  730.             cptr = *cptrptr++;
  731.             parms = (int *)cptrptr;
  732.             if (isarg) tmp = strlen(cptr);
  733.             while (*cptr) (*put)(*cptr++);
  734.             if (isarg) while (tmp++ < arg) (*put)(SP);
  735.             break;
  736.  
  737.         case 'C':        /* characters */
  738.             (*put)(*parms++);
  739.             break;
  740.  
  741.         case 'Z':        /* NUL's */
  742.             while (arg-- > 0) (*rput)(NUL);
  743.             break;
  744.  
  745.         case DEL:
  746.             while (arg-- > 0) (*rput)(DEL);
  747.             break;
  748.  
  749.         case SP:
  750.             while (arg-- > 0) (*rput)(SP);
  751.             break;
  752.  
  753.         default:
  754.             break;
  755.             }
  756.         }
  757.     }
  758.  
  759.  
  760. /* ------------------------------------------------------------ */
  761.  
  762. /* Print out an integer. */
  763.  
  764. void
  765. x_printnum(value, base, len, notfirst, iszero)
  766.     unsigned value;
  767.     int base;
  768.     int len;
  769.     FLAG notfirst;
  770.     FLAG iszero;
  771.     {
  772.     if (value >= base || (len - 1) > 0)
  773.         x_printnum(value / base, base, len - 1, TRUE, iszero);
  774.     if (!value && len > 0 && notfirst) (*put)(iszero ? '0' : SP);
  775.     else    {
  776.         value %= base;
  777.         if (value > 9) (*put)(value + 'a' - 10);
  778.         else (*put)(value + '0');
  779.         }
  780.     }
  781.  
  782.  
  783. /* ------------------------------------------------------------ */
  784.  
  785. /* Print out a long. */
  786.  
  787. void
  788. x_printlong(value, base, len, notfirst, iszero)
  789.     long value;
  790.     int base;
  791.     int len;
  792.     FLAG notfirst;
  793.     FLAG iszero;
  794.     {
  795.     if (value >= base || (len - 1) > 0)
  796.         x_printlong(value / base, base, len - 1, TRUE, iszero);
  797.     if (!value && len > 0 && notfirst) (*put)(iszero ? '0' : SP);
  798.     else    {
  799.         value %= base;
  800.         if (value > 9) (*put)((int) value + 'a' - 10);
  801.         else (*put)((int) value + '0');
  802.         }
  803.     }
  804.  
  805.  
  806. /* ------------------------------------------------------------ */
  807.  
  808. /* Print out a decimal int with commas. */
  809.  
  810. void
  811. x_printcomma(value, len, depth)
  812.     unsigned value;
  813.     int len;
  814.     int depth;
  815.     {
  816.     if (value >= 10 || (len - 1) > 0)
  817.         x_printcomma(value / 10, len - 1, depth + 1);
  818.     value %= 10;
  819.     (*put)(value + '0');
  820.     if (depth && !(depth % 3)) (*put)(',');
  821.     }
  822.  
  823.  
  824. /* ------------------------------------------------------------ */
  825.  
  826. /* Print a normal character on the terminal. */
  827.  
  828. void
  829. x_printput(c)
  830.     char c;
  831.     {
  832.     if (printptr >= &printbuf[sizeof(printbuf) - 1]) {
  833.         write(outfd, printbuf, printptr - printbuf);
  834.         printptr = printbuf;
  835.         }
  836.     *printptr++ = c;
  837.     }
  838.  
  839.  
  840. /* ------------------------------------------------------------ */
  841.  
  842. /* Print a raw character on the terminal. */
  843.  
  844. void
  845. x_printrput(c)
  846.     char c;
  847.     {
  848.     if (printptr >= &printbuf[sizeof(printbuf) - 1]) {
  849.         write(outfd, printbuf, printptr - printbuf);
  850.         printptr = printbuf;
  851.         }
  852.     *printptr++ = c;
  853.     }
  854.  
  855.  
  856. /* ------------------------------------------------------------ */
  857.  
  858. /* Print a character to a string. */
  859.  
  860. void
  861. x_printsput(c)
  862.     char c;
  863.     {
  864.     *strptr++ = c;
  865.     }
  866.  
  867. /* end of XPRINTF.C -- Printf with Extensions/Deletions (ANSI Version) */
  868.